# 定义初始字符串
s = "Hello, Python world!"
# 1. 字符串长度计算
print(len(s))
# 2. 计算字符串中"o"字符的个数
print(s.count("o"))
# 3. 将字符串转换为大写
print(s.upper())
# 4. 将字符串转换为小写
print(s.lower())
# 5. 查找"Python"在字符串中的位置
print(s.find("Python"))
# 6. 替换字符串中的"world"为"universe"
print(s.replace("world", "universe"))
# 7. 检查字符串是否以"Hello"开始
print(s.startswith("Hello"))
# 8. 检查字符串是否以"!"结尾
print(s.endswith("!"))
# 9. 以","为分隔符，拆分字符串
print(s.split(","))
# 10. 去除字符串首尾的"!"
print(s.strip("!"))
# 11. 字符串反转
# 字符串切片，开始:结束:步长
print(s[::-1])
# 12. 字符串切片，获取"Python"
print(s[s.index("Python"):s.index("Python")+len("Python")])
# 13. 将字符串s中的"Hello,"删除
print(s.replace("Hello,", ""))
# 14. 拼接两个字符串 "Hello," 和 "World!"
print("Hello," + " World!")
# 15. 使用f-string合并字符串和数字2021
print(f"Number: {2021}")
# 16. 找出'a'第一次出现的位置
# 字符串中不存在a字符，会报错
# print(s.index("a"))
# 17. 找出'e'最后一次出现的位置
print(s.rindex("e"))
# 18. 计算字符串中空格的数量
print(s.count(" "))
# 19. 使用循环遍历字符串中的每个字符
for i in s:
    print(i)
# 20. 将字符串转为"列表"形式，每个字符为一个列表元素
print(list(s))
# 21. 字符串排序（提示：先转换为列表）
print(sorted(list(s)))
# 22. 判断字符串是否为数字
print(s.isdigit())
# 23. 将列表 `['Hello,', 'Python', 'World!']` 使用空格连接为一个字符串
print(" ".join(['Hello,', 'Python', 'World!']))
# 24. 使用%操作符格式化字符串，将数字100插入到"Number: "后面
print("Number: %d" % 100)
# 25. 检查字符串是否全部为小写字母
print(s.islower())
# 26. 检查字符串是否全部为大写字母
print(s.isupper())
# 27. 将数字列表 `[1, 2, 3]` 转换成字符串，元素之间用`-`连接
print("-".join(["1", "2", "3"]))
# 28. 找出字符串中所有的"o"的位置
for i in range(len(s)):
    if s[i] == "o":
        print(i)
# 29. 替换字符串中的第一个"o"为"O"
print(s.replace("o", "O", 1))
# 30. 字符串插入操作，向字符串指定位置插入子字符串"amazing "
# s[:s.index("Python")] 切片，Python之前的字符串
# s[s.index("Python"):] Python之后的字符串
print(s[:s.index("Python")] + "amazing " + s[s.index("Python"):])






# 1. 进阶字符串
s = "Python is great!"
# 字符串反转
def reverse_string(st):
    result = []
    for i in range(len(st)-1,-1,-1):
        result.append(st[i])
    return ''.join(result)

print(reverse_string(s))

# 2. 字符计数
# 对于同一个字符串`s`，计算字符 `t'` 在其中出现的次数
def count_char(st, char):
    count = 0
    for i in st:
        if i == char:
            count += 1
    return count

print(count_char(s, 't'))

# 3. 替换字符
# 把字符串`s` 中的所有空格替换成下划线 ``
def replace_char(st, char, new_char):
    result = []
    for i in st:
        if i == char:
            result.append(new_char)
        else:
            result.append(i)
    return ''.join(result)
print(replace_char(s, ' ', '_'))

# 4. 检查回文
# 检查字符串`s2 = "A man, a plan, a canal, Panama!"` 在忽略大小写、标点和空格的情况下是否为回文字符串
s2 = "A man, a plan, a canal, Panama!"
s3 = "a b c,d,e.f ggfe d,c;ba"
def is_palindrome(st):
    # 如果空字符串，返回True
    if len(st) == 0:
        return True
    # 转换为小写
    st = st.lower()
    # 去除空格
    st.replace(' ', '')
    # 处理非字母数字字符并拼接成字符串
    st = ''.join(filter(str.isalnum, st))
    # 判断长度是否为奇数，如果是，返回False
    if len(st) % 2 != 0:
        return False
    # 遍历字符串，判断是否为回文
    for i in range(len(st)//2):
        # 判断前后字符是否相等
        if st[i] != st[-(i+1)]:
            return False
    return True
print(is_palindrome(s3))

# 5. 子字符串查找
# 在`s` 中查找第一次出现子字符串 `is"` 的位置
def find_first_substring(st, sub):
    # 子串大于主串，返回-1
    if len(sub) > len(st):
        return -1
    # 子串为空，返回-1
    if len(sub) == 0:
        return -1
    # 遍历主串
    for i in range(len(st)):
        # 判断是否为子串
        if st[i:i+len(sub)] == sub:
            return i
    # 未找到子串，返回-1
    return -1
print(find_first_substring(s,"is"))


# 6. 字符串插入
# 在`s` 中第一个 `t'` 字符之后插入子字符串`"_inserted"`
def insert_substring(st, sub):
    # 找到第一个t的位置
    index = st.find('t')
    # 判断是否存在t
    if index == -1:
        raise ValueError("子串在主串中未出现")
    # 插入子串
    return st[:index] + sub + st[index:]
print(insert_substring(s, "_inserted"))

# 7. 部分替换
# 替换`s` 中第一次出现的 `great"` 为 `awesome"`
def replace_substring(st, old_sub, new_sub):
    # 找到第一个old_sub的位置
    index = st.find(old_sub)
    # 判断是否存在old_sub
    if index == -1:
        raise ValueError("子串在主串中未出现")
    # 替换子串
    return st[:index] + new_sub + st[index+len(old_sub):]
print(replace_substring(s, "great", "awesome"))

# 8. 切片与拼接
# 将`s` 切分为两部分，其中第一部分包含前半部分的字符，第二部分包含后半部分的字符，然后将这两部分以相反顺序拼接起来。
def split_and_join(st):
    # 获取字符串长度
    length = len(st)
    # 获取前半部分长度
    half_length = length // 2
    # 切分字符串
    first_half = st[:half_length]
    second_half = st[half_length:]
    # 拼接字符串
    return second_half + first_half
print(split_and_join(s))

# 9. 创建字符串列表
# 使用列表生成式，根据字符串`s` 创建一个列表，其中包含`s` 的每个单词的首字母大写形式。
def title_upper_case(st):
    result = []
    for word in st.split():
        word = word[0].upper() + word[1:]
        result.append(word)
    return result
print(title_upper_case(s))

# 10. 字符替换加密
# 编写一个函数`encrypt`，使用字典 `a: m, b: n, ... z: l}` 的对应规则加密字符串`s3 = "encryption"`。
s3 = "encryption"
dic = {'a': 'm', 'b': 'n', 'c': 'o', 'd': 'p', 'e': 'q', 'f': 'r', 'g': 's', 'h': 't', 'i': 'u', 'j': 'v', 'k': 'w', 'l': 'x', 'm': 'y', 'n': 'z', 'o': 'a', 'p': 'b', 'q': 'c', 'r': 'd', 's': 'e', 't': 'f', 'u': 'g', 'v': 'h', 'w': 'i', 'x': 'j', 'y': 'k', 'z': 'l'}
def encrypt(st, dic):
    result = []
    for i in st:
        result.append(dic[i])
    return ''.join(result)
print(encrypt(s3, dic))